home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / exampleCode / opengl / GLUT / test / over_test.c < prev    next >
C/C++ Source or Header  |  1996-11-11  |  8KB  |  390 lines
  1.  
  2. /* Copyright (c) Mark J. Kilgard, 1996. */
  3.  
  4. /* This program is freely distributable without licensing fees 
  5.    and is provided without guarantee or warrantee expressed or 
  6.    implied. This program is -not- in the public domain. */
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <GL/glut.h>
  11.  
  12. int on = 0;
  13. int independent = 0;
  14. int main_w, hidden_w, s1, s2;
  15. float x = 0, y = 0;
  16.  
  17. void
  18. overlay_display(void)
  19. {
  20.   printf("overlay_display: damaged=%d\n", glutLayerGet(GLUT_OVERLAY_DAMAGED));
  21.   if (on) {
  22.     glutUseLayer(GLUT_OVERLAY);
  23.     glClear(GL_COLOR_BUFFER_BIT);
  24.     glBegin(GL_POLYGON);
  25.     glVertex2f(.2 + x, .2 + y);
  26.     glVertex2f(.5 + x, .5 + y);
  27.     glVertex2f(.2 + x, .5 + y);
  28.     glEnd();
  29.     glFlush();
  30.   }
  31. }
  32.  
  33. void
  34. display(void)
  35. {
  36.   printf("normal_display: damaged=%d\n", glutLayerGet(GLUT_NORMAL_DAMAGED));
  37.   glutUseLayer(GLUT_NORMAL);
  38.   glClear(GL_COLOR_BUFFER_BIT);
  39.   glColor3f(1.0, 0.0, 0.0);
  40.   glBegin(GL_POLYGON);
  41.   glVertex2f(.2, .28);
  42.   glVertex2f(.5, .58);
  43.   glVertex2f(.2, .58);
  44.   glEnd();
  45.  
  46.   if (!independent) {
  47.     overlay_display();
  48.   } else {
  49.     printf("not calling overlay_display\n");
  50.   }
  51. }
  52.  
  53. void
  54. reshape(int w, int h)
  55. {
  56.   glutUseLayer(GLUT_NORMAL);
  57.   glViewport(0, 0, w, h);
  58.  
  59.   if (on) {
  60.     glutUseLayer(GLUT_OVERLAY);
  61.     glViewport(0, 0, w, h);
  62.     printf("w=%d, h=%d\n", w, h);
  63.   }
  64. }
  65.  
  66. void
  67. special(int c, int w, int h)
  68. {
  69.   printf("special %d  w=%d h=%d\n", c, w, h);
  70.   if (on) {
  71.     switch (c) {
  72.     case GLUT_KEY_LEFT:
  73.       x -= 0.1;
  74.       break;
  75.     case GLUT_KEY_RIGHT:
  76.       x += 0.1;
  77.       break;
  78.     case GLUT_KEY_UP:
  79.       y += 0.1;
  80.       break;
  81.     case GLUT_KEY_DOWN:
  82.       y -= 0.1;
  83.       break;
  84.     }
  85.     glutPostOverlayRedisplay();
  86.   }
  87. }
  88.  
  89. void
  90. key(unsigned char c, int w, int h)
  91. {
  92.   int transP;
  93.  
  94.   printf("c=%d  w=%d h=%d\n", c, w, h);
  95.   switch (c) {
  96.   case 'e':
  97.     glutEstablishOverlay();
  98.     independent = 0;
  99.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  100.     glClearIndex(transP);
  101.     glutSetColor((transP + 1) % 2, 1.0, 1.0, 0.0);
  102.     glIndexi((transP + 1) % 2);
  103.     on = 1;
  104.     break;
  105.   case 'r':
  106.     glutRemoveOverlay();
  107.     on = 0;
  108.     break;
  109.   case 'm':
  110.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  111.       int pixel;
  112.       GLfloat red, green, blue;
  113.  
  114.       transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  115.       pixel = (transP + 1) % 2;
  116.       red = glutGetColor(pixel, GLUT_RED) + 0.2;
  117.       if (red > 1.0)
  118.         red = red - 1.0;
  119.       green = glutGetColor(pixel, GLUT_GREEN) - 0.1;
  120.       if (green > 1.0)
  121.         green = green - 1.0;
  122.       blue = glutGetColor(pixel, GLUT_BLUE) + 0.1;
  123.       if (blue > 1.0)
  124.         blue = blue - 1.0;
  125.       glutSetColor(pixel, red, green, blue);
  126.     }
  127.     break;
  128.   case 'h':
  129.     glutSetWindow(hidden_w);
  130.     glutHideWindow();
  131.     glutSetWindow(s2);
  132.     glutHideWindow();
  133.     break;
  134.   case 's':
  135.     glutSetWindow(hidden_w);
  136.     glutShowWindow();
  137.     glutSetWindow(s2);
  138.     glutShowWindow();
  139.     break;
  140.   case 'H':
  141.     glutHideOverlay();
  142.     break;
  143.   case 'S':
  144.     glutShowOverlay();
  145.     break;
  146.   case 'D':
  147.     glutDestroyWindow(main_w);
  148.     exit(0);
  149.     break;
  150.   case 'z':
  151.     {
  152.       extern void *__glutStaleWindowList;
  153.       extern void *__glutWindowWorkList;
  154.  
  155.       printf("__glutStaleWindowList = 0x%x\n", __glutStaleWindowList);
  156.       printf("__glutWindowWorkList = 0x%x\n", __glutWindowWorkList);
  157.     }
  158.     break;
  159.   case ' ':
  160.     printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
  161.     printf("layer in  use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
  162.     printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
  163.     printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
  164.     break;
  165.   }
  166. }
  167.  
  168. void
  169. key2(unsigned char c, int w, int h)
  170. {
  171.   int transP;
  172.  
  173.   printf("c=%d\n", c);
  174.   switch (c) {
  175.   case 'g':
  176.     glutReshapeWindow(
  177.       glutGet(GLUT_WINDOW_WIDTH) + 2, glutGet(GLUT_WINDOW_HEIGHT) + 2);
  178.     break;
  179.   case 's':
  180.     glutReshapeWindow(
  181.       glutGet(GLUT_WINDOW_WIDTH) - 2, glutGet(GLUT_WINDOW_HEIGHT) - 2);
  182.     break;
  183.   case 'u':
  184.     glutPopWindow();
  185.     break;
  186.   case 'd':
  187.     glutPushWindow();
  188.     break;
  189.   case 'e':
  190.     glutEstablishOverlay();
  191.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  192.     glClearIndex(transP);
  193.     glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
  194.     glIndexi((transP + 1) % 2);
  195.     break;
  196.   case 'c':
  197.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  198.       glutUseLayer(GLUT_OVERLAY);
  199.       glutCopyColormap(main_w);
  200.     }
  201.     break;
  202.   case 'r':
  203.     glutRemoveOverlay();
  204.     break;
  205.   case ' ':
  206.     printf("overlay possible: %d\n", glutLayerGet(GLUT_OVERLAY_POSSIBLE));
  207.     printf("layer in  use: %d\n", glutLayerGet(GLUT_LAYER_IN_USE));
  208.     printf("has overlay: %d\n", glutLayerGet(GLUT_HAS_OVERLAY));
  209.     printf("transparent index: %d\n", glutLayerGet(GLUT_TRANSPARENT_INDEX));
  210.     break;
  211.   }
  212. }
  213.  
  214. void
  215. vis(int state)
  216. {
  217.   if (state == GLUT_VISIBLE)
  218.     printf("visible %d\n", glutGetWindow());
  219.   else
  220.     printf("NOT visible %d\n", glutGetWindow());
  221. }
  222.  
  223. void
  224. entry(int state)
  225. {
  226.   if (state == GLUT_LEFT)
  227.     printf("LEFT %d\n", glutGetWindow());
  228.   else
  229.     printf("entered %d\n", glutGetWindow());
  230. }
  231.  
  232. void
  233. motion(int x, int y)
  234. {
  235.   printf("motion x=%x y=%d\n", x, y);
  236. }
  237.  
  238. void
  239. mouse(int b, int s, int x, int y)
  240. {
  241.   printf("b=%d  s=%d  x=%d y=%d\n", b, s, x, y);
  242. }
  243.  
  244. void
  245. display2(void)
  246. {
  247.   glutUseLayer(GLUT_NORMAL);
  248.   glClear(GL_COLOR_BUFFER_BIT);
  249.  
  250.   if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  251.     glutUseLayer(GLUT_OVERLAY);
  252.     glClear(GL_COLOR_BUFFER_BIT);
  253.     glBegin(GL_POLYGON);
  254.     glVertex2f(.2, .28);
  255.     glVertex2f(.5, .58);
  256.     glVertex2f(.2, .58);
  257.     glEnd();
  258.     glFlush();
  259.   }
  260. }
  261.  
  262. void
  263. dial(int dial, int value)
  264. {
  265.   printf("dial %d %d (%d)\n", dial, value, glutGetWindow());
  266. }
  267.  
  268. void
  269. box(int button, int state)
  270. {
  271.   printf("box %d %d (%d)\n", button, state, glutGetWindow());
  272. }
  273.  
  274. void
  275. main_menu(int option)
  276. {
  277.   switch (option) {
  278.   case 1:
  279.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  280.       independent = 1;
  281.       glutOverlayDisplayFunc(overlay_display);
  282.     }
  283.     break;
  284.   case 2:
  285.     if (glutLayerGet(GLUT_HAS_OVERLAY)) {
  286.       independent = 0;
  287.       glutOverlayDisplayFunc(NULL);
  288.     }
  289.     break;
  290.   case 666:
  291.     exit(0);
  292.     break;
  293.   }
  294. }
  295.  
  296. void
  297. s2_menu(int option)
  298. {
  299.   int transP;
  300.  
  301.   switch (option) {
  302.   case 1:
  303.     glutRemoveOverlay();
  304.     break;
  305.   case 2:
  306.     glutEstablishOverlay();
  307.     transP = glutLayerGet(GLUT_TRANSPARENT_INDEX);
  308.     glClearIndex(transP);
  309.     glutSetColor((transP + 1) % 2, 0.0, 0.25, 0.0);
  310.     glIndexi((transP + 1) % 2);
  311.     break;
  312.   case 666:
  313.     exit(0);
  314.     break;
  315.   }
  316. }
  317.  
  318. int
  319. main(int argc, char **argv)
  320. {
  321.   glutInit(&argc, argv);
  322.  
  323.   glutInitDisplayMode(GLUT_RGB);
  324.   glutInitWindowSize(210, 210);
  325.  
  326.   main_w = glutCreateWindow("overlay test");
  327.   glutDisplayFunc(display);
  328.   glutReshapeFunc(reshape);
  329.   glClearColor(1.0, 0.0, 1.0, 1.0);
  330.  
  331.   glutKeyboardFunc(key);
  332.   glutVisibilityFunc(vis);
  333.   glutEntryFunc(entry);
  334.   glutSpecialFunc(special);
  335.  
  336.   glutMotionFunc(motion);
  337.   glutMouseFunc(mouse);
  338.  
  339.   glutCreateMenu(main_menu);
  340.   glutAddMenuEntry("Dual display callbacks", 1);
  341.   glutAddMenuEntry("Single display callbacks", 2);
  342.   glutAddMenuEntry("Quit", 666);
  343.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  344.  
  345.   hidden_w = glutCreateSubWindow(main_w, 10, 10, 100, 90);
  346.   /* hidden_w is completely obscured by its own s1 subwindow.
  347.      Since it will never be displayed, no display callback need
  348.      be registered.  While entry and visibility callbacks are 
  349.      registered, they will never be called. */
  350.   glutEntryFunc(entry);
  351.   glutVisibilityFunc(vis);
  352.  
  353.   s1 = glutCreateSubWindow(hidden_w, 0, 0, 100, 90);
  354.   glClearColor(0.0, 0.0, 1.0, 1.0);
  355.   glutDisplayFunc(display2);
  356. #if 0
  357.   glutKeyboardFunc(key2);
  358. #endif
  359.   glutVisibilityFunc(vis);
  360.   glutEntryFunc(entry);
  361.  
  362.   s2 = glutCreateSubWindow(main_w, 35, 35, 100, 90);
  363.   glClearColor(0.5, 0.0, 0.5, 1.0);
  364.   glutDisplayFunc(display2);
  365. #if 1
  366.   glutKeyboardFunc(key2);
  367. #endif
  368.   glutVisibilityFunc(vis);
  369.   glutEntryFunc(entry);
  370.  
  371. #if 1
  372.   glutCreateMenu(s2_menu);
  373.   glutAddMenuEntry("Remove overlay", 1);
  374.   glutAddMenuEntry("Establish overlay", 2);
  375.   glutAddMenuEntry("Quit", 666);
  376.   glutAttachMenu(GLUT_RIGHT_BUTTON);
  377. #endif
  378.  
  379.   glutInitDisplayMode(GLUT_INDEX);
  380.  
  381. #if 1
  382.   glutSetWindow(main_w);
  383.   glutDialsFunc(dial);
  384.   glutButtonBoxFunc(box);
  385. #endif
  386.  
  387.   glutMainLoop();
  388.   return 0;             /* ANSI C requires main to return int. */
  389. }
  390.